home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / primitives / strings.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  19.9 KB  |  559 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from mapping import dictadd
  5. from util.lrucache import lru_cache
  6. import HTMLParser
  7. import StringIO
  8. import math
  9. import re
  10. import string
  11. import sys
  12. import traceback
  13.  
  14. try:
  15.     _
  16. except NameError:
  17.     
  18.     _ = lambda x: x
  19.  
  20.  
  21. def strftime_u(timeobj, fmt):
  22.     if isinstance(fmt, unicode):
  23.         fmt = fmt.encode('utf-8')
  24.     
  25.     return timeobj.strftime(fmt).decode('locale')
  26.  
  27.  
  28. def strfileobj(writefunc):
  29.     s = StringIO()
  30.     writefunc(s)
  31.     return s.getvalue()
  32.  
  33.  
  34. def strincrement(s):
  35.     return str(int(s) + 1)
  36.  
  37.  
  38. def tuple2hex(t):
  39.     return ''.join((lambda .0: for c in .0:
  40. '%02x' % c)(t[:3]))
  41.  
  42.  
  43. def format_xhtml(s, f):
  44.     s = s.replace('\n', '<br />')
  45.     font_attrs = None(None, [
  46.         None,
  47.         None,
  48.         filter,
  49.         (lambda e: bool(e)) if f.bold else '' if f.italic else '' if f.size is not None else '' if f.face is not None else ''])
  50.     style_elems = None(None, [
  51.         None,
  52.         None,
  53.         filter,
  54.         (lambda s: bool(s)) if f.foregroundcolor is not None else '' if f.backgroundcolor not in (None, (255, 255, 255, 255)) else '' if f.underline else '' if font_attrs else ''])
  55.     if style_elems:
  56.         span_style = '; '.join(style_elems)
  57.         return '<span style="%s;">%s</span>' % (span_style, s)
  58.     else:
  59.         return s
  60.  
  61. fontsizes = ((lambda x: x < 8), (lambda x: x == 8), (lambda x: x in (9, 10)), (lambda x: x in (11, 12, 13)), (lambda x: x in (14, 15, 16)), (lambda x: x in (17, 18, 19)), (lambda x: x > 19))
  62.  
  63. def Point2HTMLSize(n):
  64.     for i, f in enumerate(fontsizes):
  65.         if f(n):
  66.             return i + 1
  67.             continue
  68.     
  69.  
  70.  
  71. class StrippingParser(HTMLParser.HTMLParser):
  72.     from htmlentitydefs import entitydefs
  73.     
  74.     def __init__(self, valid_tags = ()):
  75.         HTMLParser.HTMLParser.__init__(self)
  76.         self.valid_tags = valid_tags
  77.         self.result = ''
  78.         self.endTagList = []
  79.  
  80.     
  81.     def handle_data(self, data):
  82.         if data:
  83.             self.result = self.result + data
  84.         
  85.  
  86.     
  87.     def handle_starttag(self, tag, attrs):
  88.         if tag == 'br':
  89.             self.result += '\n'
  90.         
  91.  
  92.     
  93.     def handle_charref(self, name):
  94.         self.result += chr(int(name))
  95.  
  96.     
  97.     def handle_entityref(self, name):
  98.         self.result += self.entitydefs.get(name, '')
  99.  
  100.     
  101.     def unknown_starttag(self, tag, attrs):
  102.         if tag in self.valid_tags:
  103.             self.result = self.result + '<' + tag
  104.             for k, v in attrs:
  105.                 if string.lower(k[0:2]) != 'on' and string.lower(v[0:10]) != 'javascript':
  106.                     self.result = '%s %s="%s"' % (self.result, k, v)
  107.                     continue
  108.             
  109.             endTag = '</%s>' % tag
  110.             self.endTagList.insert(0, endTag)
  111.             self.result = self.result + '>'
  112.         
  113.  
  114.     
  115.     def unknown_endtag(self, tag):
  116.         if tag in self.valid_tags:
  117.             self.result = '%s</%s>' % (self.result, tag)
  118.             remTag = '</%s>' % tag
  119.             self.endTagList.remove(remTag)
  120.         
  121.  
  122.     
  123.     def cleanup(self):
  124.         for j in range(len(self.endTagList)):
  125.             self.result = self.result + self.endTagList[j]
  126.         
  127.  
  128.  
  129. parser = StrippingParser()
  130.  
  131. def scrape_clean(text):
  132.     
  133.     def fixup(m):
  134.         text = m.group(0)
  135.         if text[:1] == '<':
  136.             return ''
  137.         
  138.         if text[:2] == '&#':
  139.             
  140.             try:
  141.                 if text[:3] == '&#x':
  142.                     return unichr(int(text[3:-1], 16))
  143.                 else:
  144.                     return unichr(int(text[2:-1]))
  145.             except ValueError:
  146.                 pass
  147.             except:
  148.                 None<EXCEPTION MATCH>ValueError
  149.             
  150.  
  151.         None<EXCEPTION MATCH>ValueError
  152.         if text[:1] == '&':
  153.             import htmlentitydefs
  154.             entity = htmlentitydefs.entitydefs.get(text[1:-1])
  155.             if entity:
  156.                 if entity[:2] == '&#':
  157.                     
  158.                     try:
  159.                         return unichr(int(entity[2:-1]))
  160.                     except ValueError:
  161.                         pass
  162.                     except:
  163.                         None<EXCEPTION MATCH>ValueError
  164.                     
  165.  
  166.                 None<EXCEPTION MATCH>ValueError
  167.                 return unicode(entity, 'iso-8859-1')
  168.             
  169.         
  170.         return text
  171.  
  172.     return re.sub('(?s)<[^>]*>|&#?\\w+;', fixup, text)
  173.  
  174.  
  175. def strip_html(s, valid_tags = ()):
  176.     parser.valid_tags = valid_tags
  177.     parser.feed(s)
  178.     parser.close()
  179.     parser.cleanup()
  180.     result = parser.result
  181.     parser.result = ''
  182.     return result
  183.  
  184.  
  185. def strip_html2(s):
  186.     if not s:
  187.         return s
  188.     
  189.     BeautifulSoup = BeautifulSoup
  190.     import util.BeautifulSoup
  191.     soup = BeautifulSoup(s.replace('<br>', '\n').replace('<br/>', '\n').replace('<br />', '\n'))
  192.     return ''.join((lambda .0: for e in .0:
  193. if isinstance(e, unicode):
  194. econtinue)(soup.recursiveChildGenerator()))
  195.  
  196. strip_html2 = lru_cache(80)(strip_html2)
  197.  
  198. def strip_html_and_tags(s, invalid_tags):
  199.     if not s:
  200.         return s
  201.     
  202.     BeautifulSoup = BeautifulSoup
  203.     import util.BeautifulSoup
  204.     soup = BeautifulSoup(s.replace('<br>', '\n').replace('<br/>', '\n').replace('<br />', '\n'))
  205.     for tag in invalid_tags:
  206.         for result in soup.findAll(name = tag):
  207.             result.replaceWith('')
  208.         
  209.     
  210.     return ''.join((lambda .0: for e in .0:
  211. if isinstance(e, unicode):
  212. econtinue)(soup.recursiveChildGenerator()))
  213.  
  214.  
  215. def srv_str_to_tuple(address, default_port):
  216.     if address.find(':') != -1:
  217.         (host, port) = address.split(':')
  218.         port = int(port)
  219.     else:
  220.         host = address
  221.         port = default_port
  222.     return (host, port)
  223.  
  224.  
  225. def get_between(s, start_str, end_str):
  226.     start_i = s.find(start_str)
  227.     end_i = s.find(end_str, start_i)
  228.     if (start_i > end_i or start_i == -1) and end_i == -1:
  229.         return None
  230.     else:
  231.         return s[start_i + len(start_str):end_i]
  232.  
  233.  
  234. def strlist(s):
  235.     lines = s.split('\n')
  236.     for y, line in enumerate(lines):
  237.         i = line.find('#')
  238.         if i != -1:
  239.             lines[y] = line[:i]
  240.             continue
  241.     
  242.     return '\n'.join(lines).split()
  243.  
  244. _curlymatcher = re.compile('\\$\\{(?P<expr>.*?)\\}', re.DOTALL)
  245.  
  246. def curly(s, frame = 2, source = None):
  247.     
  248.     def evalrepl(match, source = (source,)):
  249.         f = sys._getframe(frame)
  250.         if source is None:
  251.             source = { }
  252.         elif isinstance(source, dict):
  253.             source = source
  254.         elif hasattr(source, '__dict__'):
  255.             source = source.__dict__
  256.         elif hasattr(source, '__slots__'):
  257.             source = (dict,)((lambda .0: for x in .0:
  258. (x, getattr(source, x)))(source.__slots__))
  259.         else:
  260.             raise AssertionError('not sure what to do with this argument: %r' % source)
  261.         locals = dictadd(f.f_locals, source)
  262.         
  263.         try:
  264.             res = eval(match.group('expr'), f.f_globals, locals)
  265.         except Exception:
  266.             e = None
  267.             traceback.print_exc()
  268.             return ''
  269.             raise e
  270.  
  271.         return u'%s' % (res,)
  272.  
  273.     return _curlymatcher.sub(evalrepl, s)
  274.  
  275.  
  276. def cprint(s):
  277.     print curly(s, frame = 3)
  278.  
  279.  
  280. def replace_newlines(s, replacement = ' / ', newlines = (u'\n', u'\r')):
  281.     for newline in newlines[1:]:
  282.         s = s.replace(newline, newlines[0])
  283.     
  284.     while s.find(newlines[0] * 2) != -1:
  285.         s = s.replace(newlines[0] * 2, newlines[0])
  286.     return s.strip().replace(newlines[0], replacement)
  287.  
  288. replace_newlines = lru_cache(100)(replace_newlines)
  289.  
  290. def nicenumber(n, sep = ',', decimal = '.'):
  291.     (n, decimalpoint, decimalpart) = str(n).partition(decimal)
  292.     n = str(n)[::-1]
  293.     n = (sep.join,)((lambda .0: for i in .0:
  294. n[i:i + 3])(xrange(0, len(n), 3)))[::-1]
  295.     return ''.join([
  296.         n,
  297.         decimalpoint,
  298.         decimalpart])
  299.  
  300.  
  301. def nicebytecount(bytes):
  302.     if bytes == 0:
  303.         return '0B'
  304.     
  305.     count = 0
  306.     while math.log(bytes, 2) >= 10:
  307.         bytes = bytes / 1024
  308.         count = count + 1
  309.     return (None if int(bytes) == bytes else '%.2f' + ' %sB') % (bytes, ('', 'k', 'M', 'G', 'T', 'P')[count])
  310.  
  311.  
  312. class istr(unicode):
  313.     
  314.     def __new__(self, strng):
  315.         return unicode.__new__(self, _(strng))
  316.  
  317.     
  318.     def __init__(self, strng):
  319.         self.real = strng
  320.  
  321.     
  322.     def __cmp__(self, other):
  323.         if type(self) == type(other):
  324.             return cmp(self.real, other.real)
  325.         else:
  326.             return unicode.__cmp__(self, other)
  327.  
  328.     
  329.     def __eq__(self, other):
  330.         return not bool(self.__cmp__(other))
  331.  
  332.  
  333.  
  334. def nicetimecount(seconds, max = 2, sep = ' '):
  335.     seconds = int(seconds)
  336.     if seconds < 0:
  337.         return '-' + nicetimecount(abs(seconds), max = max, sep = sep)
  338.     
  339.     (minutes, seconds) = divmod(seconds, 60)
  340.     (hours, minutes) = divmod(minutes, 60)
  341.     (days, hours) = divmod(hours, 24)
  342.     (years, days) = divmod(days, 365)
  343.     i = 0
  344.     res = []
  345.     for thing in _('years days hours minutes seconds').split():
  346.         if not vars()[thing]:
  347.             continue
  348.         else:
  349.             res.append('%d%s' % (vars()[thing], thing[0]))
  350.             i += 1
  351.         if i == max:
  352.             break
  353.             continue
  354.     elif not res:
  355.         res = [
  356.             '0s']
  357.     
  358.     return sep.join(res)
  359.  
  360.  
  361. def unpack_pstr(s):
  362.     unpack = unpack
  363.     import struct
  364.     l = unpack('B', s[0])[0]
  365.     return (s[1:1 + l], s[1 + l:])
  366.  
  367.  
  368. def pack_pstr(s):
  369.     pack = pack
  370.     import struct
  371.     return pack('B', len(s)) + s
  372.  
  373.  
  374. def preserve_newlines(s):
  375.     return preserve_whitespace(s, nbsp = False)
  376.  
  377.  
  378. def preserve_whitespace(s, nbsp = True):
  379.     s = s.replace('\r\n', '\n').replace('\n', '<br />')
  380.     _re = re.compile('(\\s{2,})')
  381.     if not nbsp:
  382.         return s
  383.     
  384.     match = _re.search(s)
  385.     while match:
  386.         spaces = match.groups()[0]
  387.         s = s.replace(spaces, len(spaces) * ' ', 1)
  388.         match = _re.search(s)
  389.     return s
  390.  
  391.  
  392. class EncodedString(object):
  393.     
  394.     def __init__(self, s, encodings = None):
  395.         if encodings is None:
  396.             encodings = ()
  397.         
  398.         self.encodings = tuple(encodings)
  399.         self._data = s
  400.  
  401.     
  402.     def encode(self, encoding):
  403.         return EncodedString(self._data.encode(encoding), self.encodings + (encoding,))
  404.  
  405.     
  406.     def decodeAll(self):
  407.         s = self
  408.         while s.encodings:
  409.             s = s.decode()
  410.         return s
  411.  
  412.     
  413.     def decode(self):
  414.         encoding = self.encodings[-1]
  415.         newencodings = self.encodings[:-1]
  416.         return EncodedString(self._data.decode(encoding), newencodings)
  417.  
  418.     
  419.     def __getattr__(self, attr):
  420.         if attr in ('encodings', '_data', 'encode', 'decode', 'decodeAll'):
  421.             return object.__getattribute__(self, attr)
  422.         else:
  423.             return self._data.__getattribute__(attr)
  424.  
  425.     
  426.     def __repr__(self):
  427.         return '<%s (%s) encodings=%r>' % (type(self).__name__, repr(self._data), self.encodings)
  428.  
  429.     
  430.     def __str__(self):
  431.         if type(self._data) is str:
  432.             return self._data
  433.         else:
  434.             raise TypeError('%r cannot be implicitly converted to str')
  435.  
  436.     
  437.     def __unicode__(self):
  438.         if type(self._data) is unicode:
  439.             return self._data
  440.         else:
  441.             raise TypeError('%r cannot be implicitly converted to unicode')
  442.  
  443.  
  444. estring = EncodedString
  445.  
  446. def try_all_encodings(s):
  447.     successes = []
  448.     import encodings
  449.     codecs = set(encodings.aliases.aliases.values())
  450.     for c in codecs:
  451.         
  452.         try:
  453.             decoded = s.decode(c)
  454.         except (Exception,):
  455.             continue
  456.             continue
  457.  
  458.         if isinstance(decoded, unicode):
  459.             
  460.             try:
  461.                 recoded = decoded.encode('utf8')
  462.             except UnicodeEncodeError:
  463.                 continue
  464.             except:
  465.                 None<EXCEPTION MATCH>UnicodeEncodeError
  466.             
  467.  
  468.         None<EXCEPTION MATCH>UnicodeEncodeError
  469.         if isinstance(recoded, str) and isinstance(decoded, unicode):
  470.             codec = c
  471.             successes.append((s, codec, decoded, recoded))
  472.             continue
  473.     else:
  474.         decoded = None
  475.         recoded = None
  476.         codec = None
  477.     return successes
  478.  
  479.  
  480. def saferepr(obj):
  481.     
  482.     try:
  483.         return repr(obj)
  484.     except Exception:
  485.         
  486.         try:
  487.             return '<%s>' % obj.__class__.__name__
  488.         except Exception:
  489.             return '<??>'
  490.         except:
  491.             None<EXCEPTION MATCH>Exception
  492.         
  493.  
  494.         None<EXCEPTION MATCH>Exception
  495.  
  496.  
  497.  
  498. def wireshark_format(data):
  499.     out = StringIO()
  500.     safe = set(string.printable) - set(string.whitespace) | set(' ')
  501.     
  502.     def hex(s):
  503.         return ' '.join((lambda .0: for ch in .0:
  504. '%02X' % ord(ch))(s))
  505.  
  506.     
  507.     def safe_bin(s):
  508.         return (''.join,)((lambda .0: for ch in .0:
  509. None if ch in safe else '.')(s))
  510.  
  511.     
  512.     def pad(s, l, ch = ' '):
  513.         return s + ch * (l - len(s))
  514.  
  515.     w = out.write
  516.     space = '    '
  517.     while data:
  518.         chunk1 = data[:8]
  519.         chunk2 = data[8:16]
  520.         data = data[16:]
  521.         w(pad(hex(chunk1), 24))
  522.         w(space)
  523.         w(pad(hex(chunk2), 24))
  524.         w(space)
  525.         w(pad(safe_bin(chunk1), 8))
  526.         w(space)
  527.         w(pad(safe_bin(chunk2), 8))
  528.         w('\n')
  529.         continue
  530.         (None,)
  531.     return out.getvalue()
  532.  
  533.  
  534. def to_hex(string, spacer = ' '):
  535.     return spacer.join((lambda .0: for byte in .0:
  536. '%02X' % ord(byte))(string))
  537.  
  538.  
  539. def byte_print(string_, spacer = ' '):
  540.     import string as strng
  541.     output = ''
  542.     for i in range(len(string_) / 16 + 1):
  543.         line = string_[i * 16:i * 16 + 16]
  544.         pline = (''.join,)((lambda .0: for x in .0:
  545. None if x in strng.printable else '.')(line))
  546.         pline = pline.replace('\n', ' ')
  547.         pline = pline.replace('\r', ' ')
  548.         pline = pline.replace('\t', ' ')
  549.         pline = pline.replace('\x0b', ' ')
  550.         pline = pline.replace('\x0c', ' ')
  551.         output += to_hex(line) + ' ' + pline + '\n'
  552.     
  553.     return output
  554.  
  555. if __name__ == '__main__':
  556.     import doctest
  557.     doctest.testmod(verbose = True)
  558.  
  559.